

<!DOCTYPE html>
<html lang="zh-CN" data-default-color-scheme=&#34;auto&#34;>



<head>
  <meta charset="UTF-8">
  <link rel="apple-touch-icon" sizes="76x76" href="/img/2.jpg">
  <link rel="icon" type="image/png" href="/img/2.jpg">
  <meta name="viewport"
        content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, shrink-to-fit=no">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  
  <meta name="theme-color" content="#2f4154">
  <meta name="description" content="">
  <meta name="author" content="K">
  <meta name="keywords" content="">
  <title>python-函数作用域和特别的函数以及装饰器 - K</title>

  <link  rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/4.4.1/css/bootstrap.min.css" />


  <link  rel="stylesheet" href="https://cdn.staticfile.org/github-markdown-css/4.0.0/github-markdown.min.css" />
  <link  rel="stylesheet" href="/lib/hint/hint.min.css" />

  
    
    
      
      <link  rel="stylesheet" href="https://cdn.staticfile.org/highlight.js/10.0.0/styles/github-gist.min.css" />
    
  

  


<!-- 主题依赖的图标库，不要自行修改 -->

<link rel="stylesheet" href="//at.alicdn.com/t/font_1749284_ba1fz6golrf.css">



<link rel="stylesheet" href="//at.alicdn.com/t/font_1736178_kmeydafke9r.css">


<link  rel="stylesheet" href="/css/main.css" />

<!-- 自定义样式保持在最底部 -->


  <script  src="/js/utils.js" ></script>
  <script  src="/js/color-schema.js" ></script>
<meta name="generator" content="Hexo 5.2.0"></head>


<body>
  <header style="height: 70vh;">
    <nav id="navbar" class="navbar fixed-top  navbar-expand-lg navbar-dark scrolling-navbar">
  <div class="container">
    <a class="navbar-brand"
       href="/">&nbsp;<strong>かい</strong>&nbsp;</a>

    <button id="navbar-toggler-btn" class="navbar-toggler" type="button" data-toggle="collapse"
            data-target="#navbarSupportedContent"
            aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <div class="animated-icon"><span></span><span></span><span></span></div>
    </button>

    <!-- Collapsible content -->
    <div class="collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav ml-auto text-center">
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/">
                <i class="iconfont icon-home-fill"></i>
                首页
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/archives/">
                <i class="iconfont icon-archive-fill"></i>
                归档
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/categories/">
                <i class="iconfont icon-category-fill"></i>
                分类
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/tags/">
                <i class="iconfont icon-tags-fill"></i>
                标签
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/about/">
                <i class="iconfont icon-user-fill"></i>
                关于
              </a>
            </li>
          
        
        
          <li class="nav-item" id="search-btn">
            <a class="nav-link" data-toggle="modal" data-target="#modalSearch">&nbsp;<i
                class="iconfont icon-search"></i>&nbsp;</a>
          </li>
        
        
          <li class="nav-item" id="color-toggle-btn">
            <a class="nav-link" href="javascript:">&nbsp;<i
                class="iconfont icon-dark" id="color-toggle-icon"></i>&nbsp;</a>
          </li>
        
      </ul>
    </div>
  </div>
</nav>

    <div class="banner intro-2" id="background" parallax=true
         style="background: url('/img/1.jpg') no-repeat center center;
           background-size: cover;">
      <div class="full-bg-img">
        <div class="mask flex-center" style="background-color: rgba(0, 0, 0, 0.3)">
          <div class="container page-header text-center fade-in-up">
            <span class="h2" id="subtitle">
              
            </span>

            
              <div class="mt-3">
  
  
    <span class="post-meta">
      <i class="iconfont icon-date-fill" aria-hidden="true"></i>
      <time datetime="2020-08-05 16:32" pubdate>
        2020年8月5日 下午
      </time>
    </span>
  
</div>

<div class="mt-1">
  
    
    <span class="post-meta mr-2">
      <i class="iconfont icon-chart"></i>
      4.5k 字
    </span>
  

  
    
    <span class="post-meta mr-2">
      <i class="iconfont icon-clock-fill"></i>
      
      
      53
       分钟
    </span>
  

  
  
</div>

            
          </div>

          
        </div>
      </div>
    </div>
  </header>

  <main>
    
      

<div class="container-fluid">
  <div class="row">
    <div class="d-none d-lg-block col-lg-2"></div>
    <div class="col-lg-8 nopadding-md">
      <div class="container nopadding-md" id="board-ctn">
        <div class="py-5" id="board">
          <article class="post-content mx-auto" id="post">
            <!-- SEO header -->
            <h1 style="display: none">python-函数作用域和特别的函数以及装饰器</h1>
            
            <div class="markdown-body" id="post-body">
              <h2 id="文档字符串"><a href="#文档字符串" class="headerlink" title="文档字符串"></a>文档字符串</h2><ul>
<li><p>help()函数 是python的内置函数</p>
</li>
<li><p>通过help()函数可以查询python函数的用法</p>
</li>
<li><p>语法：<br> <code>help(函数对象)</code></p>
<pre><code class="hljs bash"><span class="hljs-built_in">help</span>(<span class="hljs-built_in">print</span>)
这是查看<span class="hljs-built_in">print</span>函数的用法</code></pre></li>
<li><p>文档字符串（doc str）</p>
</li>
<li><p>在定义函数时，可以在函数的内部编写文档字符串，文档字符串就是函数的说明</p>
</li>
<li><p>当我们编写了文档字符串是，就可以通过help()函数来查看函数的说明</p>
</li>
<li><p>文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串</p>
</li>
<li><p>就是在函数添加多行注释</p>
<pre><code class="hljs python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lmk</span>(<span class="hljs-params">*nums</span>) :</span>
<span class="hljs-string">&#x27;&#x27;&#x27;</span>
<span class="hljs-string">hello             # 这个就是函数的说明</span>
<span class="hljs-string">&#x27;&#x27;&#x27;</span>
	b = <span class="hljs-number">0</span> 
	<span class="hljs-keyword">for</span> a <span class="hljs-keyword">in</span> nums :
		b += a
	<span class="hljs-keyword">return</span> b</code></pre>
<pre><code class="hljs python"><span class="hljs-comment"># 也可以在函数名那里明确参数的类型</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lmk</span> (<span class="hljs-params">*nums:<span class="hljs-built_in">int</span></span>) -&gt; int:</span>
	<span class="hljs-string">&#x27;&#x27;&#x27;</span>
<span class="hljs-string"> 	  这是一个计算任何数字的函数，会把这些数字相加</span>
<span class="hljs-string">	&#x27;&#x27;&#x27;</span>
    k = <span class="hljs-number">0</span>
    <span class="hljs-keyword">for</span> e <span class="hljs-keyword">in</span> nums :   
        k += e
  	<span class="hljs-keyword">return</span> k   
<span class="hljs-built_in">help</span>(lmk)
<span class="hljs-comment"># 可以在 形参后面明确这个形参是int 还是str 等，也可以在括号后面加 -&gt; int </span>
<span class="hljs-comment"># 这个意思是，这个函数会返回什么样类型的值，就可以简单的理解这个函数的用法</span>
<span class="hljs-comment"># 输出结果是</span>
	<span class="hljs-comment"># Help on function lmk in module __main__:</span>
		<span class="hljs-comment"># lmk(*nums:int) -&gt; int</span>
<span class="hljs-comment"># -&gt; int	这个函数的注释解释是最终会返回int型 </span></code></pre>

</li>
</ul>
<h2 id="作用域"><a href="#作用域" class="headerlink" title="作用域"></a>作用域</h2><ul>
<li><p>作用域指的是比那辆生效的区域</p>
</li>
<li><p>在python中一共有两种作用域</p>
</li>
<li><p>全局作用域</p>
<ul>
<li>全局作用域在程序执行时创建，在程序执行结束时销毁，就是在函数外定义的变量都是在全局作用域定义的</li>
<li>所有在函数外的区域都是全局作用域</li>
<li>在全局作用域中定义的变量在全局作用域定义的变量都属于全局变量，全局变量可以在程序的任意位置被访问</li>
</ul>
</li>
<li><p>函数作用域</p>
<ul>
<li>函数作用域在函数调用时创建，在函数调用结束时销毁</li>
<li>函数每次调用一次就会产生一个新的函数作用域，就是每调用一次就相当于又重新再函数里定义了一个只在函数作用域中生效的函数，并在函数执行完后销毁</li>
<li>在函数作用域中定义的变量，都是局部变量，只能在函数内部生效被访问</li>
<li>函数作用域中的变量可以和全局作用域中的变量共同使用，但是在全局作用域中吊用不了函数作用域中的变量，只能通过调用函数使用函数作用域中的变量</li>
</ul>
</li>
<li><p>变量的查找</p>
<ul>
<li>当使用变量时，会优先在当前作用域中寻找该变量，如果有，则使用，没有的话就向上一级作用域中寻找，以此类推知道找到位置</li>
<li>如果从函数作用域找到全局作用域都没找到的话就会抛出异常，nameError<pre><code class="hljs ruby">a = <span class="hljs-number">10</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lmk</span> <span class="hljs-params">()</span></span><span class="hljs-symbol">:</span>
    print(<span class="hljs-string">&#x27;a is&#x27;</span>,a)

lmk()	
<span class="hljs-comment"># 这个例子是 在函数作用域中没有变量，因为没有函数的嵌套所以直接找到了全局作用域 所以输出的a是全局的</span>
<span class="hljs-comment"># 如果在函数内部定义了一个a变量，则输出的a是函数内部的变量，优先输出当前作用域的变量</span></code></pre>
<pre><code class="hljs ruby">a = <span class="hljs-number">10</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lmk</span> <span class="hljs-params">()</span></span><span class="hljs-symbol">:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">kml</span><span class="hljs-params">()</span></span><span class="hljs-symbol">:</span>
        b = <span class="hljs-number">20</span>
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lmk1</span><span class="hljs-params">()</span></span><span class="hljs-symbol">:</span>
        	c = <span class="hljs-number">100</span>
          	print(a,b,c)  
        lmk1()
   	kml()
lmk()
<span class="hljs-comment"># 这个是函数嵌套三层</span>
<span class="hljs-comment"># 要先看最里面的函数</span>
<span class="hljs-comment"># 输出a,b,c 最里面的函数作用域只定义了一个c 没有定义a 和b 所以往外找，在往上一层函数作用域中找到了b</span>
<span class="hljs-comment"># 没有找到a，所以再次往上找，所有函数作用域中都没有a,所以找到了全局作用域中，在全局作用域中定义了a</span>

<span class="hljs-comment"># 所以输出结果是 10 20 100</span>
	<span class="hljs-comment"># 最后提一点，在全局作用域中是不能使用函数作用域中定义的变量的值的</span></code></pre></li>
</ul>
</li>
<li><p>如果在全局作用域中定义了a 在函数作用域中也定义了a,并且希望全局作用域中的a改为函数作用域的a可以用global声明<br><code>global 全局变量名</code></p>
<pre><code class="hljs livecodeserver"><span class="hljs-keyword">a</span> = <span class="hljs-number">10</span>
def lmk ():
	<span class="hljs-keyword">a</span> = <span class="hljs-number">20</span> 
   	print(<span class="hljs-keyword">a</span>)
lmk()
print(<span class="hljs-keyword">a</span>)        <span class="hljs-comment"># 这个输出结果是 20 10</span>
<span class="hljs-comment"># 在函数内修改a没有改变全局作用域中的a</span>
<span class="hljs-comment">----------------------------------------------------------</span>
<span class="hljs-keyword">a</span> = <span class="hljs-number">10</span>
def lmk ():           
	<span class="hljs-built_in">global</span> <span class="hljs-keyword">a</span>             <span class="hljs-comment"># 声明在函数内部使用的a是全局变量，此时再去修改a时，就是在修改a的全局变量</span>
	<span class="hljs-keyword">a</span> = <span class="hljs-number">20</span>                 <span class="hljs-comment"># 在函数中为变量赋值是都是为全局变量赋值        </span>
	print(<span class="hljs-keyword">a</span>)
lmk()
print(<span class="hljs-keyword">a</span>)       <span class="hljs-comment"># 这个输出结果是 20 20   全局作用域中的a已经被改为 20了</span>
</code></pre>
<blockquote>
<p>也可以这么理解，在全局作用域中的变量可以在函数作用域中修改，不过要先声明要修改函数为全局变量<br>在声明好后再去定义变量，就相当于修改全局作用域的变量了，在global之前的变量依然属于函数作用域的变量</p>
</blockquote>
</li>
</ul>
<h2 id="递归函数"><a href="#递归函数" class="headerlink" title="递归函数"></a>递归函数</h2><ul>
<li>递归函数就是在函数内部再次调用自己<pre><code class="hljs rust">def <span class="hljs-function"><span class="hljs-keyword">fn</span></span>():
	# 在函数内部再次调用了自己
	<span class="hljs-function"><span class="hljs-keyword">fn</span></span>()
<span class="hljs-function"><span class="hljs-keyword">fn</span></span>()
# 这个就是递归函数，而且是无穷递归,和<span class="hljs-keyword">while</span> <span class="hljs-literal">true</span> 差不多</code></pre></li>
<li>递归是解决问题的一种方式，和循环很像</li>
<li>它的整体思想是将一个大的问题拆分成一个个小的问题，直到问题无法拆分时，再去解决问题</li>
<li>递归函数的两个要件<br>1.基线条件<br> 问题可以被分解为的最小问题，当满足基线条件时，递归就不在执行了<br>2.递归条件<br> 将问题继续分解的条件，直到无法分解后结束递归<pre><code class="hljs python"><span class="hljs-comment"># 这个例子是创建一个递归函数求任意数的阶乘</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">factorial</span>(<span class="hljs-params">n</span>) -&gt; int:</span>
    <span class="hljs-comment"># 该函数用来求任意数的阶乘</span>
	<span class="hljs-comment"># 参数：</span>
        <span class="hljs-comment"># n 要求阶乘的数字</span>
   	<span class="hljs-keyword">if</span> n == <span class="hljs-number">1</span> :
        <span class="hljs-keyword">return</span> <span class="hljs-number">1</span> 
    <span class="hljs-keyword">return</span> n * factorial(n<span class="hljs-number">-1</span>)
print(factorial(<span class="hljs-number">20</span>))</code></pre>

</li>
</ul>
<h2 id="编程式函数"><a href="#编程式函数" class="headerlink" title="编程式函数"></a>编程式函数</h2><ul>
<li>在python中函数是一种对象</li>
<li>对象都会具有以下特点<ul>
<li>对象是在运行时创建的</li>
<li>能赋值给变量或作为数据结构的元素</li>
<li>能作为参数传递</li>
<li>能作为返回值返回</li>
</ul>
</li>
</ul>
<h2 id="高阶函数"><a href="#高阶函数" class="headerlink" title="高阶函数"></a>高阶函数</h2><ul>
<li><p>高阶函数至少要符合一下两个特点中的一个</p>
<ul>
<li><p>接收一个或多个函数作为参数</p>
</li>
<li><p>将函数作为返回值返回</p>
</li>
<li><p>高阶函数就是在函数中调用其他的函数，达到一定的功能，</p>
</li>
<li><p>高阶函数不会使原先的变量改变，而是返回一个新的列表</p>
<pre><code class="hljs yaml"><span class="hljs-comment"># 创建一个判断偶数的函数</span>
<span class="hljs-string">def</span> <span class="hljs-string">fn1(n)</span> <span class="hljs-string">:</span>
    <span class="hljs-string">if</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-string">==</span> <span class="hljs-attr">0:</span>
        <span class="hljs-string">return</span> <span class="hljs-string">n</span>
<span class="hljs-comment"># 创建一个判断奇数的函数</span>
<span class="hljs-string">def</span> <span class="hljs-string">fn2(n)</span> <span class="hljs-string">:</span>
    <span class="hljs-string">if</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-type">!=</span> <span class="hljs-attr">0 :</span>
        <span class="hljs-string">return</span> <span class="hljs-string">n</span>

<span class="hljs-comment"># 创建一个列表</span>
<span class="hljs-string">l</span> <span class="hljs-string">=</span> [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>,<span class="hljs-number">7</span>,<span class="hljs-number">8</span>,<span class="hljs-number">9</span>,<span class="hljs-number">10</span>]

<span class="hljs-comment"># 定义一个函数</span>

<span class="hljs-string">def</span> <span class="hljs-string">fn(lmk,lst):</span>

   <span class="hljs-comment"># 创建一个新的列表</span>
    <span class="hljs-string">new_list</span> <span class="hljs-string">=</span> []

    <span class="hljs-comment"># 对列表进行筛选</span>
    <span class="hljs-attr">for n in lst :</span>
        <span class="hljs-comment"># 判断n的奇偶</span>
        <span class="hljs-string">if</span> <span class="hljs-string">lmk(n):</span>             <span class="hljs-comment"># lmk是一个形参 取决于用户调用哪一个参数</span>
            <span class="hljs-string">new_list.append(n)</span>
    <span class="hljs-string">return</span> <span class="hljs-string">new_list</span>
	<span class="hljs-comment"># 返回列表</span>

<span class="hljs-string">print(fn(fn1,l))</span>                       
<span class="hljs-comment"># 一共写了三个函数，最后一个函数分别调用前面两个函数来完成不同的功能，这就是高阶函数</span>
</code></pre>
<blockquote>
<p>以上是创建了一个高阶函数供参考，还有一个函数适用于高阶函数</p>
</blockquote>
</li>
</ul>
</li>
<li><p>filter() 函数</p>
<ul>
<li>可以从序列中过滤出符合条件的元素，保存到新的序列中</li>
<li>参数：<br><code>filter(函数,序列)</code><br>1，函数 根据该函数过滤（可迭代结构）  和刚才最后一个函数调用前两个函数一样的<br>2，需要过滤的序列（可迭代的结构）<br>返回值：       返回值返回的是过滤后的新序列<pre><code class="hljs yaml"><span class="hljs-comment"># 创建一个判断偶数的函数</span>
<span class="hljs-string">def</span> <span class="hljs-string">fn1(n)</span> <span class="hljs-string">:</span>
	<span class="hljs-string">if</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-string">==</span> <span class="hljs-attr">0:</span>
	    <span class="hljs-string">return</span> <span class="hljs-string">n</span>

<span class="hljs-comment"># 创建一个判断奇数的函数</span>
<span class="hljs-string">def</span> <span class="hljs-string">fn2(n)</span> <span class="hljs-string">:</span>
	<span class="hljs-string">if</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-type">!=</span> <span class="hljs-attr">0 :</span>
	    <span class="hljs-string">return</span> <span class="hljs-string">n</span>

<span class="hljs-comment"># 创建一个列表</span>
<span class="hljs-string">l</span> <span class="hljs-string">=</span> [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>,<span class="hljs-number">7</span>,<span class="hljs-number">8</span>,<span class="hljs-number">9</span>,<span class="hljs-number">10</span>]	

<span class="hljs-comment"># 调用filter()函数</span>
				<span class="hljs-comment"># 输出filter过滤后的序列，要转换成列表才能查看，要不然看到的是filter的可迭代的结构</span>
<span class="hljs-string">print(list(filter(fn1,l)))</span>	<span class="hljs-comment"># 输出结果是 &quot;[2, 4, 6, 8, 10]&quot; 偶数</span>
<span class="hljs-string">print(list(filter(fn2,l)))</span>  <span class="hljs-comment"># 输出结果是 [1, 3, 5, 7, 9] 奇数</span>
 
</code></pre>

</li>
</ul>
</li>
</ul>
<h2 id="匿名函数"><a href="#匿名函数" class="headerlink" title="匿名函数"></a>匿名函数</h2><ul>
<li>lambda()函数表达式专门用来创建一些简单的函数，它是函数创建的又一种方式<br> 语法：<br> <code>lambda 参数列表 : 返回值</code></li>
<li>匿名函数一般都是作为参数使用，其他地方一般不会使用<pre><code class="hljs yaml"><span class="hljs-comment"># 创建一个列表</span>
<span class="hljs-string">l</span> <span class="hljs-string">=</span> [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>,<span class="hljs-number">7</span>,<span class="hljs-number">8</span>,<span class="hljs-number">9</span>,<span class="hljs-number">10</span>]

<span class="hljs-comment"># 创建一个判断偶数的函数</span>
<span class="hljs-string">def</span> <span class="hljs-string">fn1(n)</span> <span class="hljs-string">:</span>
	<span class="hljs-string">if</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-string">==</span> <span class="hljs-attr">0:</span>
	    <span class="hljs-string">return</span> <span class="hljs-string">n</span>
<span class="hljs-comment"># 创建一个判断奇数的函数</span>
<span class="hljs-string">def</span> <span class="hljs-string">fn2(n)</span> <span class="hljs-string">:</span>
	<span class="hljs-string">if</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-type">!=</span> <span class="hljs-attr">0 :</span>
	    <span class="hljs-string">return</span> <span class="hljs-string">n</span>	
<span class="hljs-comment"># --------------------------------------------------------</span>
<span class="hljs-comment"># 上面这两个函数可以用匿名函数创建</span>
<span class="hljs-string">print(list(filter(lambda</span> <span class="hljs-attr">n :</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-string">==</span> <span class="hljs-number">0</span><span class="hljs-string">,l)))</span>           
<span class="hljs-comment">#  lambda n : n % 2 == 0 这个就是判断参数是否是偶数    再用filter函数过滤 就完美了，就是这么用的</span>
<span class="hljs-string">print(list(filter(lambda</span> <span class="hljs-attr">n :</span> <span class="hljs-string">n</span> <span class="hljs-string">%</span> <span class="hljs-number">2</span> <span class="hljs-type">!=</span> <span class="hljs-number">0</span><span class="hljs-string">,l)))</span>            
<span class="hljs-comment"># lambda n : n % 2 != 0 判断是否为奇数</span>
<span class="hljs-comment"># 两个的输出结果</span>
 	<span class="hljs-comment"># &quot;[2, 4, 6, 8, 10]</span>
	<span class="hljs-comment"># [1, 3, 5, 7, 9]      </span></code></pre>



</li>
</ul>
<ul>
<li>map() </li>
<li>map() 函数可以对迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回</li>
<li>可以对序列中的每个元素进行操作<br>格式:<br><code>map(函数,序列)</code><pre><code class="hljs angelscript"># 创建一个列表
l = [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>,<span class="hljs-number">7</span>,<span class="hljs-number">8</span>,<span class="hljs-number">9</span>,<span class="hljs-number">10</span>]	
a = map(lambda n : n + <span class="hljs-number">2</span> ,l)        

print(list(a)) 
# 输出结果是 	[<span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">10</span>, <span class="hljs-number">11</span>, <span class="hljs-number">12</span>] 每个元素都加<span class="hljs-number">2</span>返回一个新的列表，而源列表不变</code></pre>



</li>
</ul>
<ul>
<li>sort()<ul>
<li>该方法用来对列表中的元素进行排序，从小到大</li>
<li>sort()方法默认是直接比较列表中元素的大小</li>
<li>在sort()方法中可以接收一个关键字参数，key<ul>
<li>格式<br><code>列表.sort(key=函数)</code></li>
</ul>
</li>
<li>key需要一个函数作为参数，当设置了函数作为参数</li>
<li>每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小</li>
<li>加入key这个参数时，列表中的元素先转换为函数的返回值，然后sort（）方法再进行排序<pre><code class="hljs 1c">l = [&#x27;11&#x27;,&#x27;2&#x27;,&#x27;<span class="hljs-number">3333</span>&#x27;,&#x27;444&#x27;,&#x27;<span class="hljs-number">55555555</span>&#x27;,&#x27;<span class="hljs-number">7777777777</span>&#x27;,&#x27;<span class="hljs-number">66666666666666</span><span class="hljs-number">6666</span>&#x27;]
l.sort()
print(l)												
<span class="hljs-meta"># 没有加入参数key，是默认按列表里元素的大小来排序的</span>
<span class="hljs-meta"># 输出结果     &quot;[&#x27;11&#x27;, &#x27;2&#x27;, &#x27;3333&#x27;, &#x27;444&#x27;, &#x27;55555555&#x27;, &#x27;666666666666666666&#x27;, &#x27;7777777777&#x27;]</span>
<span class="hljs-meta"># ----------------------------------------------------------------------------------------------	</span>
<span class="hljs-meta"># 加入key	</span>
l = [&#x27;11&#x27;,&#x27;2&#x27;,&#x27;<span class="hljs-number">3333</span>&#x27;,&#x27;444&#x27;,&#x27;<span class="hljs-number">55555555</span>&#x27;,&#x27;<span class="hljs-number">7777777777</span>&#x27;,&#x27;<span class="hljs-number">66666666666666</span><span class="hljs-number">6666</span>&#x27;]
l.sort(key=len)
print(l)
<span class="hljs-meta"># 加入了一个len函数，列表会先经过len函数，再通过sort方法进行排序</span>
<span class="hljs-meta"># 返回结果是    [&#x27;2&#x27;, &#x27;11&#x27;, &#x27;444&#x27;, &#x27;3333&#x27;, &#x27;55555555&#x27;, &#x27;7777777777&#x27;, &#x27;666666666666666666&#x27;]</span>
<span class="hljs-meta"># 用这个方法会改变原序列的顺序</span></code></pre>



</li>
</ul>
</li>
</ul>
<ul>
<li>sorted() <ul>
<li>该函数和sort()用法基本一致，但是sorted()可以对任意的序列进行排序</li>
<li>并且使用sorted()排序不会影响原来的对象，而是返回一个新的对象</li>
<li>sorted可以对任意序列进行排序，而sort只能对列表进行排序，两个的实现的功能都相同<pre><code class="hljs routeros">l = [<span class="hljs-string">&#x27;11&#x27;</span>,<span class="hljs-string">&#x27;2&#x27;</span>,<span class="hljs-string">&#x27;3333&#x27;</span>,<span class="hljs-string">&#x27;444&#x27;</span>,<span class="hljs-string">&#x27;55555555&#x27;</span>,<span class="hljs-string">&#x27;7777777777&#x27;</span>,<span class="hljs-string">&#x27;666666666666666666&#x27;</span>]
<span class="hljs-builtin-name">print</span>(<span class="hljs-string">&#x27;排序前&#x27;</span>,l)
sorted(l)
<span class="hljs-builtin-name">print</span>(<span class="hljs-string">&#x27;排序后&#x27;</span>,l)
<span class="hljs-comment"># 输出结果是 </span>
<span class="hljs-comment">#排序前 &quot;[&#x27;11&#x27;, &#x27;2&#x27;, &#x27;3333&#x27;, &#x27;444&#x27;, &#x27;55555555&#x27;, &#x27;7777777777&#x27;, &#x27;666666666666666666&#x27;]</span>
<span class="hljs-comment">#排序后 [&#x27;11&#x27;, &#x27;2&#x27;, &#x27;3333&#x27;, &#x27;444&#x27;, &#x27;55555555&#x27;, &#x27;7777777777&#x27;, &#x27;666666666666666666&#x27;]</span>
<span class="hljs-comment"># 可以看到没有改变但是打印sorted(l) 就可以看到新的序列了</span>
<span class="hljs-comment"># print(sorted(l))      输出结果是</span>
              # [<span class="hljs-string">&#x27;11&#x27;</span>, <span class="hljs-string">&#x27;2&#x27;</span>, <span class="hljs-string">&#x27;3333&#x27;</span>, <span class="hljs-string">&#x27;444&#x27;</span>, <span class="hljs-string">&#x27;55555555&#x27;</span>, <span class="hljs-string">&#x27;666666666666666666&#x27;</span>, <span class="hljs-string">&#x27;7777777777&#x27;</span>]
		
<span class="hljs-comment"># 加入key参数后</span>
l = [<span class="hljs-string">&#x27;11&#x27;</span>,<span class="hljs-string">&#x27;2&#x27;</span>,<span class="hljs-string">&#x27;3333&#x27;</span>,<span class="hljs-string">&#x27;444&#x27;</span>,<span class="hljs-string">&#x27;55555555&#x27;</span>,<span class="hljs-string">&#x27;7777777777&#x27;</span>,<span class="hljs-string">&#x27;666666666666666666&#x27;</span>]
<span class="hljs-builtin-name">print</span>(sorted(l,<span class="hljs-attribute">key</span>=len))
<span class="hljs-comment"># 输出结果是</span>
          # [<span class="hljs-string">&#x27;2&#x27;</span>, <span class="hljs-string">&#x27;11&#x27;</span>, <span class="hljs-string">&#x27;444&#x27;</span>, <span class="hljs-string">&#x27;3333&#x27;</span>, <span class="hljs-string">&#x27;55555555&#x27;</span>, <span class="hljs-string">&#x27;7777777777&#x27;</span>, <span class="hljs-string">&#x27;666666666666666666&#x27;</span>]
<span class="hljs-comment"># 序列按照长度进行排序了</span>
</code></pre>

</li>
</ul>
</li>
</ul>
<h2 id="闭包"><a href="#闭包" class="headerlink" title="闭包"></a>闭包</h2><ul>
<li><p>将函数作为返回值返回，也是一种高阶函数</p>
</li>
<li><p>这种函数我们也称为闭包，通过闭包可以创建一些只有当前函数能访问的变量，</p>
<blockquote>
<p>就是之前在全局作用域中的变量，我们放到第一个函数作用域，然后再创建一个函数去访问第一个函数作用域，并且返回值是函数里的函数，也就是返回我们编写功能的函数作用域，而第一个函数作用域里的变量在全局作用域中就访问不到了</p>
</blockquote>
</li>
<li><p>可以将一些私有数据藏到闭包中</p>
<pre><code class="hljs ruby"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fn</span><span class="hljs-params">()</span></span><span class="hljs-symbol">:</span>
  a = <span class="hljs-number">10</span> 
<span class="hljs-comment">#函数内部再定义一个函数</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">inner</span><span class="hljs-params">()</span></span><span class="hljs-symbol">:</span>
        print(<span class="hljs-string">&#x27;inner&#x27;</span>,a)
    <span class="hljs-comment">#将返回值 inner作为返回值返回</span>
	<span class="hljs-keyword">return</span> inner
r = fn()
r()
<span class="hljs-comment"># r是一个函数是fn()后的返回函数,不用r接收fn()函数是看不到 inner函数的返回值的</span>
<span class="hljs-comment"># 这个函数是在fn()内部定义，并不是全局函数</span>
<span class="hljs-comment"># 所以这个函数可以访问到fn()函数内的变量</span>
<span class="hljs-comment"># 而在全局作用域中是没有a这个对象的</span>
<span class="hljs-comment"># 这个函数最后的输出结果是 inner 10 是函数内函数的返回值，在全局变量打印a是打印不出来的</span></code></pre></li>
<li><p>怎样形成闭包</p>
<ul>
<li>形成闭包的3要件<br>1，函数嵌套<br>2，将内部函数作为返回值返回<br>3，内部函数必须使用外部函数的变量<pre><code class="hljs python"><span class="hljs-comment"># 这个例子是在闭包中定义一个求平均值的功能</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">make_average</span>():</span>
	<span class="hljs-comment"># 创建一个列表用来保存数值 </span>
	nums = []
	<span class="hljs-comment"># 创建一个函数，用来计算平均值</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">average</span>(<span class="hljs-params">n</span>):</span>
	    <span class="hljs-comment"># 将 用户传入的参数 n 添加到上层函数的列表中</span>
	    nums.append(n)
	    <span class="hljs-comment"># 求平均值 用到 sum()函数，作用是列表中数的和</span>
	    <span class="hljs-keyword">return</span> <span class="hljs-built_in">sum</span>(nums)/<span class="hljs-built_in">len</span>(nums)
	<span class="hljs-keyword">return</span> average

<span class="hljs-comment"># average 去接收make_average这个函数</span>
average = make_average()
<span class="hljs-comment"># 往列表添加函数，打印平均值</span>
print(average(<span class="hljs-number">10</span>))
print(average(<span class="hljs-number">15</span>))
print(average(<span class="hljs-number">20</span>))</code></pre>

</li>
</ul>
</li>
</ul>
<h2 id="装饰器"><a href="#装饰器" class="headerlink" title="装饰器"></a>装饰器</h2><ul>
<li><p>装饰器也是一种高阶函数</p>
</li>
<li><p>我们在调用函数时，如果感觉函数的功能还不是很好用，可以为这个函数扩展一下，而我们扩展函数的功能就会修改这个函数</p>
</li>
<li><p>所以就有了装饰器</p>
<blockquote>
<p>我们先定义一个函数实现 两个数相加</p>
</blockquote>
<pre><code class="hljs ruby"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">jia</span><span class="hljs-params">(a,b)</span></span><span class="hljs-symbol">:</span>
   	rest = a + b
   	<span class="hljs-keyword">return</span> rest</code></pre>
<ul>
<li>希望在函数计算前打印开始计算，计算结束后打印计算完毕<blockquote>
<p>如果我们直接修改函数中的代码完成需求，会产生以下的问题<br>1，如果要修改的函数过多，修改起来会比较麻烦<br>2，不方便后期维护<br>3，并且这样做会违反开闭原则（ocp）</p>
</blockquote>
</li>
<li>程序的设计，要求开发对程序的扩展，要关闭对程序的修改</li>
<li>如果这个函数或方法是开放的，就不能去修改源代码，要不然会有很多困扰</li>
<li>对扩展开放对修改关闭<pre><code class="hljs python"><span class="hljs-comment"># 上面定义了一个两个数相加的函数</span>
<span class="hljs-comment"># 现在对这个函数进行扩展</span>
<span class="hljs-comment"># 原函数--</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">jia</span>(<span class="hljs-params">a,b</span>):</span>
	rest = a + b
	<span class="hljs-keyword">return</span> rest
-----------------------------------------------------------------------------------------
<span class="hljs-comment"># 扩展后--</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">kuozhan_jia</span>(<span class="hljs-params">a,b</span>):</span>
	print(<span class="hljs-string">&#x27;计算开始&#x27;</span>)
	c = jia(a,b)
	print(<span class="hljs-string">&#x27;计算结束&#x27;</span>)
	<span class="hljs-keyword">return</span> c

print(kuozhan_jia(<span class="hljs-number">5</span>,<span class="hljs-number">5</span>))
<span class="hljs-comment"># 以上就是再不修改源函数的前提下对原函数进行扩展 扩展后的结果是</span>
			<span class="hljs-comment"># 计算开始</span>
			<span class="hljs-comment"># 计算结束</span>
			<span class="hljs-comment"># 10</span></code></pre></li>
</ul>
</li>
<li><p>上面这个是达到了基本的要求了，但是不够灵活，如果还有一个原函数也需要这样修改就要定义两个扩展函数了</p>
<pre><code class="hljs python"><span class="hljs-comment"># 可以创建一个函数，让这个函数自动帮我们生产函数</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">jia</span>(<span class="hljs-params">a,b</span>):</span>
	rest = a + b
	<span class="hljs-keyword">return</span> rest


<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">kuozhan_jia</span>(<span class="hljs-params">old</span>):</span>
	<span class="hljs-comment"># old 是要扩展的函数名</span>
	<span class="hljs-string">&#x27;&#x27;&#x27;</span>
<span class="hljs-string">	用来对其他函数进行扩展，是其他函数可以在执行前打印开始，执行后的打印结束</span>
<span class="hljs-string">		参数 </span>
<span class="hljs-string"> 		    old 要扩展的对象</span>
<span class="hljs-string">	&#x27;&#x27;&#x27;</span>

	<span class="hljs-comment"># 创建一个 新函数 ，我们每调一次上层函数就会创建一个新函数</span>
 	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">new_jia</span>(<span class="hljs-params">*a,**b</span>):</span>
  		<span class="hljs-comment"># 这里的 *a是接收所有的位置参数，有就接收，没有就不接受,**b是接收所有的关键字参数，有就接收，没有就不接收</span>
		print(<span class="hljs-string">&#x27;开始&#x27;</span>)
		<span class="hljs-comment"># 调用被扩展的函数</span>
		c = old(*a,**b)
		<span class="hljs-comment"># 这里的是调用函数，所以就是把上层函数接收的*a和**b解包，然后调用*a是元组，**b是字典</span>
		print(<span class="hljs-string">&#x27;结束&#x27;</span>)
		<span class="hljs-comment"># c是接收old这个函数运行的结果然后return 返回给new_jia这个函数 ，然后上层函数返回new_jia </span>
		<span class="hljs-keyword">return</span> c
	<span class="hljs-comment"># 返回里层函数，因为实在函数作用域中返回的，所以全局作用域是看不到的，我们就返回给第一层函数 </span>
	<span class="hljs-keyword">return</span> new_jia

<span class="hljs-comment"># 调用装饰器</span>
kuozhan_jia(jia(<span class="hljs-number">1</span>,<span class="hljs-number">2</span>))

<span class="hljs-comment"># 这个kuozhan_jia就是装饰器</span>
<span class="hljs-comment"># 通过装饰器可以在不修改原来函数的情况下对函数进行扩展</span></code></pre>
</li>
<li><p>上面这个装饰器一般不这么用</p>
<pre><code class="hljs python"><span class="hljs-meta">@kuozhan_jia              </span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">chang</span>(<span class="hljs-params">a</span>):</span>
	b = <span class="hljs-built_in">len</span>(a)
	<span class="hljs-keyword">return</span> b
print(chang(<span class="hljs-string">&#x27;sdfkljsdfj&#x27;</span>))
	
<span class="hljs-comment"># 通过@符号调用装饰器来对下面定义的函数进行修改</span>

<span class="hljs-comment"># 通常在定义函数时，在定义函数上一行来用装饰器进行扩展，然后函数就有了扩展功能</span>
		<span class="hljs-comment"># 输出结果是 </span>
		<span class="hljs-comment"># 开始</span>
		<span class="hljs-comment"># 结束</span>
		<span class="hljs-comment"># 10</span>
<span class="hljs-comment"># 可以为一个函数指定多个装饰器</span>
<span class="hljs-comment"># 一般装饰器先在里面装饰然后最外边装饰全部的</span>
<span class="hljs-comment"># 函数会由内到外进行装饰</span></code></pre></li>
</ul>

            </div>
            <hr>
            <div>
              <div class="post-metas mb-3">
                
                  <div class="post-meta mr-3">
                    <i class="iconfont icon-category"></i>
                    
                      <a class="hover-with-bg" href="/categories/python/">python</a>
                    
                  </div>
                
                
                  <div class="post-meta">
                    <i class="iconfont icon-tags"></i>
                    
                      <a class="hover-with-bg" href="/tags/python%E5%9F%BA%E7%A1%80/">python基础</a>
                    
                  </div>
                
              </div>
              
                <p class="note note-warning">本博客所有文章是以学习为目的，如果有不对的地方可以一起交流沟通共同学习 邮箱:1248287831@qq.com！</p>
              
              
                <div class="post-prevnext row">
                  <article class="post-prev col-6">
                    
                    
                      <a href="/2020/08/06/python%E5%AF%B9%E8%B1%A1/">
                        <i class="iconfont icon-arrowleft"></i>
                        <span class="hidden-mobile">python对象以及面向对象的理解</span>
                        <span class="visible-mobile">上一篇</span>
                      </a>
                    
                  </article>
                  <article class="post-next col-6">
                    
                    
                      <a href="/2020/07/24/python%E5%87%BD%E6%95%B0/">
                        <span class="hidden-mobile">python函数</span>
                        <span class="visible-mobile">下一篇</span>
                        <i class="iconfont icon-arrowright"></i>
                      </a>
                    
                  </article>
                </div>
              
            </div>

            
          </article>
        </div>
      </div>
    </div>
    
      <div class="d-none d-lg-block col-lg-2 toc-container" id="toc-ctn">
        <div id="toc">
  <p class="toc-header"><i class="iconfont icon-list"></i>&nbsp;目录</p>
  <div id="tocbot"></div>
</div>

      </div>
    
  </div>
</div>

<!-- Custom -->


    
  </main>

  
    <a id="scroll-top-button" href="#" role="button">
      <i class="iconfont icon-arrowup" aria-hidden="true"></i>
    </a>
  

  
    <div class="modal fade" id="modalSearch" tabindex="-1" role="dialog" aria-labelledby="ModalLabel"
     aria-hidden="true">
  <div class="modal-dialog modal-dialog-scrollable modal-lg" role="document">
    <div class="modal-content">
      <div class="modal-header text-center">
        <h4 class="modal-title w-100 font-weight-bold">搜索</h4>
        <button type="button" id="local-search-close" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body mx-3">
        <div class="md-form mb-5">
          <input type="text" id="local-search-input" class="form-control validate">
          <label data-error="x" data-success="v"
                 for="local-search-input">关键词</label>
        </div>
        <div class="list-group" id="local-search-result"></div>
      </div>
    </div>
  </div>
</div>
  

  

  <footer class="text-center mt-5 py-3">
  <div class="footer-content">
     <a href="https://space.bilibili.com/39165374" target="_blank" rel="nofollow noopener"><span>LMK</span></a> <i class="iconfont icon-love"></i> <a href="https://github.com/fluid-dev/hexo-theme-fluid" target="_blank" rel="nofollow noopener"><span>Fluid</span></a> 
  </div>
  
  <div class="statistics">
    
    

    
      
        <!-- 不蒜子统计PV -->
        <span id="busuanzi_container_site_pv" style="display: none">
            总访问量 
            <span id="busuanzi_value_site_pv"></span>
             次
          </span>
      
      
        <!-- 不蒜子统计UV -->
        <span id="busuanzi_container_site_uv" style="display: none">
            总访客数 
            <span id="busuanzi_value_site_uv"></span>
             人
          </span>
      
    
  </div>


  

  
</footer>

<!-- SCRIPTS -->
<script  src="https://cdn.staticfile.org/jquery/3.4.1/jquery.min.js" ></script>
<script  src="https://cdn.staticfile.org/twitter-bootstrap/4.4.1/js/bootstrap.min.js" ></script>
<script  src="/js/debouncer.js" ></script>
<script  src="/js/main.js" ></script>

<!-- Plugins -->


  
    <script  src="/js/lazyload.js" ></script>
  



  



  <script defer src="https://cdn.staticfile.org/clipboard.js/2.0.6/clipboard.min.js" ></script>
  <script  src="/js/clipboard-use.js" ></script>



  <script defer src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js" ></script>





  <script  src="https://cdn.staticfile.org/tocbot/4.11.1/tocbot.min.js" ></script>
  <script>
    $(document).ready(function () {
      var boardCtn = $('#board-ctn');
      var boardTop = boardCtn.offset().top;

      tocbot.init({
        tocSelector: '#tocbot',
        contentSelector: '#post-body',
        headingSelector: 'h1,h2,h3,h4,h5,h6',
        linkClass: 'tocbot-link',
        activeLinkClass: 'tocbot-active-link',
        listClass: 'tocbot-list',
        isCollapsedClass: 'tocbot-is-collapsed',
        collapsibleClass: 'tocbot-is-collapsible',
        collapseDepth: 0,
        scrollSmooth: true,
        headingsOffset: -boardTop
      });
      if ($('.toc-list-item').length > 0) {
        $('#toc').css('visibility', 'visible');
      }
    });
  </script>



  <script  src="https://cdn.staticfile.org/typed.js/2.0.11/typed.min.js" ></script>
  <script>
    var typed = new Typed('#subtitle', {
      strings: [
        '  ',
        "python-函数作用域和特别的函数以及装饰器&nbsp;",
      ],
      cursorChar: "_",
      typeSpeed: 70,
      loop: false,
    });
    typed.stop();
    $(document).ready(function () {
      $(".typed-cursor").addClass("h2");
      typed.start();
    });
  </script>



  <script  src="https://cdn.staticfile.org/anchor-js/4.2.2/anchor.min.js" ></script>
  <script>
    anchors.options = {
      placement: "right",
      visible: "hover",
      
    };
    var el = "h1,h2,h3,h4,h5,h6".split(",");
    var res = [];
    for (item of el) {
      res.push(".markdown-body > " + item)
    }
    anchors.add(res.join(", "))
  </script>



  <script  src="/js/local-search.js" ></script>
  <script>
    var path = "/local-search.xml";
    var inputArea = document.querySelector("#local-search-input");
    inputArea.onclick = function () {
      searchFunc(path, 'local-search-input', 'local-search-result');
      this.onclick = null
    }
  </script>



  <script  src="https://cdn.staticfile.org/fancybox/3.5.7/jquery.fancybox.min.js" ></script>
  <link  rel="stylesheet" href="https://cdn.staticfile.org/fancybox/3.5.7/jquery.fancybox.min.css" />

  <script>
    $('#post img:not(.no-zoom img, img[no-zoom]), img[zoom]').each(
      function () {
        var element = document.createElement('a');
        $(element).attr('data-fancybox', 'images');
        $(element).attr('href', $(this).attr('src'));
        $(this).wrap(element);
      }
    );
  </script>















</body>
</html>
